Just Call Me Internet/Just Call Me Internet.iso/prog/atari/m2/cat3src/cat/msglistb.i

Text File | 1997-10-26 | 88KB | 2,739 lines

IMPLEMENTATION MODULE MsgListBase;


(*==============================================================*
 * Modul:               CAT-Basismodul fr Stichwortlisten      *
 * Autor:               Dirk Steins                             *
 * erstellt am:         27.07.1995                              *
 * letzte Žnderung am:  27.07.1995                              *
 * Version:             0.1                                     *
 * Interne Version:     V#0001                                  *
 *==============================================================*

 *----------------------------------------------------------------------------
 * Datum    Vers. Autor  Žnderung (Arbeitsbericht)
 *----------------------------------------------------------------------------
 *----------------------------------------------------------------------------
 *)

(*-- MM2-Module ------------------------------------------------------------*)
FROM SYSTEM     IMPORT ADDRESS, ADR, TSIZE, CALLSYS, CADR;
FROM Storage    IMPORT ALLOCATE, DEALLOCATE;
IMPORT Lists;
IMPORT GrafBase;
IMPORT BinOps;
IMPORT Strings;
IMPORT StrConv;
IMPORT MOSGlobals;
IMPORT Keyboard;
IMPORT Block;
FROM Keyboard  IMPORT SpecialCode;

(*-- Cat-Module ------------------------------------------------------------*)
FROM Void         IMPORT v;
FROM UserInformation IMPORT UserBLK;

IMPORT data;
IMPORT dataSys;
IMPORT EditTypes;
IMPORT MTE;
IMPORT VDIStandards;
IMPORT VDIUtil;
IMPORT MausTauschrsc;
IMPORT CatTypes;
IMPORT handlePool;
IMPORT ConfVars;
IMPORT WdwManager;
IMPORT RectFuncs;
IMPORT FontSelect;
IMPORT CatGlobal;
IMPORT CatFiles;
IMPORT grin;
IMPORT grinTools;
IMPORT Varnames;
IMPORT QuickSort;
IMPORT ZSearchDial;
IMPORT GroupSelect;
IMPORT Clip;
IMPORT SearchHelp;
IMPORT AssFuncs;
IMPORT ConvertDate;
IMPORT Protokoll;

(*-- Magic-Lib -------------------------------------------------------------*)
IMPORT MagicStrings;
IMPORT MagicAES;
IMPORT MagicVDI;
IMPORT MagicFSM;
IMPORT MagicDOS;
IMPORT MagicConvert;

(*-- Magic-Tools -----------------------------------------------------------*)
IMPORT mtAppl;
IMPORT mtArea;
IMPORT mtUtils;
IMPORT mtAlerts;
IMPORT mtDials;
IMPORT mtPopups;
IMPORT mtTextfiles;
IMPORT mtXobjects;

(* ---- msgList, zirkul„rer Import auf Implementationsbasis *)

IMPORT msgList;

(*-------------- Suchfunktionen in Liste -----------------------*)

TYPE intPtr     = POINTER TO INTEGER;
     cardPtr    = POINTER TO CARDINAL;
     adrPtr     = POINTER TO ADDRESS;

(*$A+,Z-*)
PROCEDURE FindWinCond(e, i : ADDRESS):BOOLEAN;
(* Abbruchprozedur, wie in <Lists> gefordert *)
BEGIN
  RETURN listWdwPtr(e)^.wdw = intPtr(i)^
END FindWinCond;

PROCEDURE FindHandleCond(e, i : ADDRESS):BOOLEAN;
(* Abbruchprozedur, wie in <Lists> gefordert *)
BEGIN
  RETURN e = adrPtr(i)^
END FindHandleCond;

PROCEDURE FindGroupCond (e, i : ADDRESS): BOOLEAN;
BEGIN
  RETURN listWdwPtr(e)^.grHandle^.group = cardPtr(i)^
END FindGroupCond;
(*$A=,Z=*)

TYPE NumSet  = SET OF [0..255];

VAR listNums : NumSet;


PROCEDURE FindNum () : INTEGER;
  VAR i : INTEGER;
BEGIN
  IF (globalNumber >= 0) &
     ~ (globalNumber IN listNums)
  THEN
    INCL (listNums, globalNumber);
    i := globalNumber;
    globalNumber := -1;
    RETURN i
  END;
  FOR i := 0 TO 255 DO
    IF ~(i IN listNums) THEN INCL (listNums, i); RETURN i; END;
  END;
END FindNum;

PROCEDURE ClearNum (num : INTEGER);
BEGIN
  EXCL (listNums, num);
END ClearNum;

(*-------------- Serviceprozeduren fr grin (next/prev) -------*)
PROCEDURE findMsgIdx (ptr : listWdwPtr; which: CARDINAL; VAR idx : CARDINAL);
  VAR i : CARDINAL;
BEGIN
  WITH ptr^ DO
    IF (which <= maxPos) &
       (list^[which].msgNum = which)
    THEN
      idx := which
    ELSE
      FOR i := maxPos TO 0 BY -1 DO
        IF list^[i].msgNum = which THEN idx := i; RETURN END
      END;
      idx := dataSys.empty;
    END;
  END;
END findMsgIdx;

PROCEDURE FindNextSelected (ptr : listWdwPtr; which : CARDINAL) : CARDINAL;
  VAR i, idx : CARDINAL;
      bits   : BITSET;
BEGIN
  (* Messageindex suchen *)
  findMsgIdx (ptr, which, idx);
  IF idx < dataSys.notSaved
  THEN
    WITH ptr^ DO
      FOR i := idx+1 TO maxPos DO
        IF Selected IN list^[i].flags THEN
          IF unreadOrNew & UserBLK.ignoreRead & ~(initRead IN list^[i].flags)
          THEN
            data.ReadState (grHandle^.Zugriff, list^[i].msgNum, bits);
            IF ~(dataSys.bGelesen IN bits)
            THEN
              RETURN list^[i].msgNum
            END;
          ELSE
            RETURN list^[i].msgNum
          END;
        END;
      END;
    END;
  END;
  RETURN dataSys.empty
END FindNextSelected;

PROCEDURE FindPrevSelected (ptr : listWdwPtr; which : CARDINAL) : CARDINAL;
  VAR i, idx : CARDINAL;
      bits   : BITSET;
BEGIN
  (* Messageindex suchen *)
  findMsgIdx (ptr, which, idx);
  IF idx < dataSys.notSaved
  THEN
    WITH ptr^ DO
      IF idx > 0
      THEN
        FOR i := idx-1 TO 0 BY -1 DO
          IF Selected IN list^[i].flags THEN
            IF unreadOrNew & UserBLK.ignoreRead & ~(initRead IN list^[i].flags)
            THEN
              data.ReadState (grHandle^.Zugriff, list^[i].msgNum, bits);
              IF ~(dataSys.bGelesen IN bits)
              THEN
                RETURN list^[i].msgNum
              END;
            ELSE
              RETURN list^[i].msgNum
            END;
          END;
        END;
      END;
    END;
  END;
  RETURN dataSys.empty
END FindPrevSelected;

(* Deselektierte suchen, fr Bestimmung von neuer Startpoistion *)
PROCEDURE FindNextDeselected (ptr : listWdwPtr; which : CARDINAL) : CARDINAL;
  VAR i, idx : CARDINAL;
BEGIN
  (* Messageindex suchen *)
  findMsgIdx (ptr, which, idx);
  IF idx < dataSys.notSaved
  THEN
    WITH ptr^ DO
      FOR i := idx+1 TO maxPos DO
        IF ~(Selected IN list^[i].flags) THEN RETURN list^[i].msgNum END;
      END;
    END;
  END;
  RETURN ptr^.maxPos+1
END FindNextDeselected;

PROCEDURE FindPrevDeselected (ptr : listWdwPtr; which : CARDINAL) : CARDINAL;
  VAR i, idx : CARDINAL;
BEGIN
  (* Messageindex suchen *)
  findMsgIdx (ptr, which, idx);
  IF idx < dataSys.notSaved
  THEN
    WITH ptr^ DO
      IF idx > 0
      THEN
        FOR i := idx-1 TO 0 BY -1 DO
          IF ~(Selected IN list^[i].flags) THEN RETURN list^[i].msgNum END;
        END;
      END;
    END;
  END;
  RETURN dataSys.empty;
END FindPrevDeselected;

PROCEDURE listNextMess (which : CARDINAL; nextJN, withShift: BOOLEAN; listHdl: LONGCARD; wdw : ADDRESS):CARDINAL;
  VAR ptr : listWdwPtr;
BEGIN
  IF handlePool.FindEntry(ADR(listHdl), FindHandleCond, windows, ptr) THEN
    IF nextJN
    THEN
      RETURN FindNextSelected (ptr, which)
    ELSE
      RETURN FindPrevSelected (ptr, which)
    END;
  ELSE
    RETURN grin.grinNextMess (which, nextJN, withShift, 0, NIL);
  END;
END listNextMess;

PROCEDURE hasSelectedEntries (ptr : listWdwPtr; VAR first : CARDINAL): BOOLEAN;
  VAR i : CARDINAL;
BEGIN
  WITH ptr^ DO
    FOR i := 0 TO maxPos DO
      IF Selected IN list^[i].flags THEN first := i; RETURN TRUE
      END;
    END;
  END;
  RETURN FALSE;
END hasSelectedEntries;

PROCEDURE countSelectedEntries (ptr : listWdwPtr) : CARDINAL;
  VAR i : CARDINAL;
      (*$Reg *) counter : CARDINAL;
BEGIN
  WITH ptr^ DO
    counter := 0;
    FOR i := 0 TO maxPos DO
      IF Selected IN list^[i].flags THEN INC (counter)
      END;
    END;
  END;
  RETURN counter;
END countSelectedEntries;

(*-------------- Selektion von Eintr„gen ----------------------*)
PROCEDURE toggleBit (VAR s : BITSET; bit: INTEGER);
BEGIN
  IF bit IN s
  THEN EXCL (s, bit)
  ELSE INCL (s, bit);
  END;
END toggleBit;

PROCEDURE redrawEntry (ptr : listWdwPtr; entry: CARDINAL);
  VAR rect : GrafBase.Rectangle;
BEGIN
  WITH ptr^ DO
    IF entry > maxPos THEN RETURN END;
    rect := listWork;
    INC (rect.x, pixOffset);
    rect.y := rect.y + INTEGER(entry - startPos) * (charHeight+lineDist);
    rect.h := charHeight + lineDist;
    WdwManager.RedrawWdw (wdw, rect);
    EXCL (list^[entry].flags, doRedraw);
    WdwManager.SetClip (vdi, listWork, TRUE);
  END;
END redrawEntry;

PROCEDURE toggleEntry (ptr : listWdwPtr; entry: CARDINAL);
BEGIN
  WITH ptr^ DO
    IF entry > maxPos THEN RETURN END;
    toggleBit (list^[entry].flags, Selected);
    redrawEntry (ptr, entry);
  END;
END toggleEntry;

PROCEDURE invertSelection (ptr: listWdwPtr);
  VAR i         : CARDINAL;
BEGIN
  WITH ptr^ DO
    FOR i := 0 TO maxPos DO
      toggleBit (list^[i].flags, Selected);
    END;
    (* kompletten Redraw ausl”sen *)
    WdwManager.FullRedrawWdw (ptr^.wdw);
  END;
END invertSelection;

PROCEDURE deselectEntries (ptr : listWdwPtr);
  VAR i         : CARDINAL;
      rect      : GrafBase.Rectangle;
      first     : BOOLEAN;
BEGIN
  WITH ptr^ DO
    rect := listWork;
    INC (rect.x, pixOffset);
    rect.h := charHeight + lineDist;
    first := TRUE;
    FOR i := 0 TO maxPos DO
      IF Selected IN list^[i].flags
      THEN
        EXCL (list^[i].flags, Selected);
        IF (i >= startPos) & (i <= startPos + CARDINAL(windLines))
        THEN
          (* redraw *)
          IF first THEN
            rect.y := listWork.y + INTEGER(i - startPos) * (charHeight+lineDist);
            first := FALSE
          ELSE
            rect.h := listWork.y + INTEGER(i - startPos + 1) * (charHeight+lineDist) - rect.y;
          END;
        END;
      END;
    END;
    IF ~first THEN WdwManager.RedrawWdw (wdw, rect) END;
  END;
END deselectEntries;

PROCEDURE deselectReadEntries (ptr : listWdwPtr);
  VAR i         : CARDINAL;
      rect      : GrafBase.Rectangle;
      first     : BOOLEAN;
      bits      : BITSET;
BEGIN
  WITH ptr^ DO
    rect := listWork;
    INC (rect.x, pixOffset);
    rect.h := charHeight + lineDist;
    first := TRUE;
    FOR i := 0 TO maxPos DO
      IF ~(firstRead IN list^[i].flags)
      THEN
        (* Wurde noch gar nicht gelesen, mal schnell den Readstatus
         * dazu rausfinden
         *)
        data.ReadState (grHandle^.Zugriff, list^[i].msgNum, bits);
        IF dataSys.bGelesen IN bits
        THEN
          EXCL (list^[i].flags, notRead);
        ELSE
          INCL (list^[i].flags, notRead);
        END;
      END;
      IF (Selected IN list^[i].flags) & ~(notRead IN list^[i].flags)
      THEN
        EXCL (list^[i].flags, Selected);
        IF (i >= startPos) & (i <= startPos + CARDINAL(windLines))
        THEN
          (* redraw *)
          IF first THEN
            rect.y := listWork.y + INTEGER(i - startPos) * (charHeight+lineDist);
            first := FALSE
          ELSE
            rect.h := listWork.y + INTEGER(i - startPos + 1) * (charHeight+lineDist) - rect.y;
          END;
        END;
      END;
    END;
    IF ~first THEN WdwManager.RedrawWdw (wdw, rect) END;
  END;
END deselectReadEntries;

(* --------------------- Cursorbehandlung ------------------*)

PROCEDURE drawCursor (ptr: listWdwPtr);
  VAR line : ARRAY [0..4] OF GrafBase.Point;
      fill : GrafBase.Rectangle;
      xOutput, yOutput : INTEGER;
      style : CARDINAL;
BEGIN
  WITH ptr^ DO
    (* Zeichnet einen gepunkteten Rahmen um die Zeile mit der aktuellen
     * Cursorposition
     *)
    IF (cursPos >= LONGINT(LONG(startPos))) & (cursPos <= LONGINT (LONG(startPos + CARDINAL(windLines) - 1)))
    THEN
      (* Cursor ist sichtbar, also zeichnen *)
      xOutput := listWork.x + pixOffset - leftOffset;
      yOutput := listWork.y + SHORT (cursPos - LONGINT(LONG(startPos))) * (charHeight + lineDist) + (lineDist DIV 2);
      line[0].x := xOutput;
      line[0].y := yOutput;
      line[1].x := xOutput+entryWidth-1;
      line[1].y := yOutput;
      line[2].x := xOutput+entryWidth-1;
      line[2].y := yOutput+charHeight-1;
      line[3].x := xOutput;
      line[3].y := yOutput+charHeight-1;
      line[4].x := xOutput;
      line[4].y := yOutput;
      (* Schreibmodus setzen *)
      v.int := MagicVDI.SetWritemode (vdi, MagicVDI.XOR);
      (* Linientyp setzen *)
      v.int := MagicVDI.SetLinetype (vdi, MagicVDI.User);
      IF ODD (leftOffset)
      THEN
        style := $AAAA;
      ELSE
        style := $5555;
      END;
      MagicVDI.SetUserlinestyle (vdi, style);
      v.int := MagicVDI.SetLinewidth (vdi, 1);
      v.int := MagicVDI.SetLinecolor (vdi, 1);
      MagicVDI.Polyline (vdi, 5, line);
      (* Jetzt PixOffset am linken Rand ggf. l”schen *)
      v.int := MagicVDI.SetWritemode (vdi, MagicVDI.REPLACE);
      v.int := MagicVDI.SetFillcolor (vdi, CatGlobal.listBackCol);  (* Weiž *)
      fill.x := listWork.x;
      fill.y := yOutput;
      fill.w := listWork.x + pixOffset - 1;
      fill.h := yOutput + charHeight - 1;
      MagicVDI.FillRectangle(vdi, fill);
      (* Schreibmodus zurcksetzen *)
      v.int := MagicVDI.SetWritemode (vdi, MagicVDI.TRANSPARENT);
    END;
  END;
END drawCursor;

PROCEDURE ShowCursor (ptr : listWdwPtr);
  VAR r : GrafBase.Rectangle;
BEGIN
  WITH ptr^ DO
    IF (cursPos >= LONGINT(LONG(startPos))) & (cursPos <= LONGINT (LONG(startPos + CARDINAL(windLines) - 1)))
    THEN
      (* Cursor ist sichtbar, also zeichnen *)
      (* WindUpdate und Maus ausschalten *)
      updateListWdw (wdw, vdi, ADR(ptr), TRUE);
      IF WdwManager.RectList (wdw, 0, r)
      THEN
        REPEAT
          (* ClipRechteck setzen *)
          WdwManager.SetClip (vdi, r, TRUE);
          (* Zeichnen *)
          drawCursor (ptr);
        UNTIL ~WdwManager.RectList (wdw, 1, r);
      END;
      (* WindUpdate wieder aus und Maus anschalten *)
      updateListWdw (wdw, vdi, ADR(ptr), FALSE);
    END;
  END;
END ShowCursor;

(*-------------- Funktionen fr WdwManager --------------------*)

PROCEDURE AdjustTreePos (r: GrafBase.Rectangle; VAR rt : GrafBase.Rectangle);
BEGIN
  WITH butBox^[0] DO
    obX := r.x;
    obY := r.y;
    obWidth := r.w;
    rt.x := obX; rt.y := obY;
    rt.w := obWidth; rt.h := obHeight+1;
  END;
  (* Jetzt Userdef prfen *)
  IF butBox^[MausTauschrsc.listread].obType # MagicAES.GPROGDEF
  THEN
    v.bool := mtXobjects.InstUserdef (butBox, MausTauschrsc.listread, mtDials.DrawButton, NIL);
  END;
END AdjustTreePos;

PROCEDURE GetLinePart (ptr: listWdwPtr; num : CARDINAL; VAR mess : data.MessageType;
                       VAR line : ARRAY OF CHAR; type : partType);
  VAR tmpStr : ARRAY [0..1023] OF CHAR;
      maxLen : CARDINAL;
      i      : CARDINAL;
      p, n   : INTEGER;
      ch     : CHAR;
      fStr   : partFormat;
      dt     : ConvertDate.Date;
      ti     : ConvertDate.Time;

  PROCEDURE CheckAssign (strPtr: CatTypes.Str255Ptr; VAR str : ARRAY OF CHAR);
  BEGIN
    IF strPtr # NIL
    THEN
      Strings.Assign (strPtr^, str, v.bool);
    ELSE
      Strings.Assign ("(not available)", str, v.bool);
    END;
  END CheckAssign;

BEGIN
  IF (type.type = pRealName) &
     ((mess.name^[0] = '') OR mess.EigeneNachricht)
  THEN
    type.type := pUserName;
  END;
  CASE type.type OF
    pRealName,
    pUserName  : IF mess.EigeneNachricht & (mess.Gruppe = dataSys.private)
                 THEN
                   Strings.Copy ('An: ', 0, BinOps.LowerInt (type.w, 4), line, v.bool);
                   CheckAssign (mess.Empfaenger, tmpStr);
                   maxLen := BinOps.HigherInt (0, type.w - 4);
                 ELSE
                   IF type.type = pRealName
                   THEN
                     CheckAssign (mess.name, tmpStr);
                   ELSE
                     CheckAssign (mess.Absender, tmpStr);
                   END;
                   line[0]:= '';
                   maxLen := type.w;
                 END;
                 CatGlobal.KurzName (tmpStr, tmpStr, maxLen);
                 (*
                 IF LENGTH (tmpStr) > maxLen
                 THEN
                   (* Erstmal Vornamen abkrzen *)
                   p := 0;
                   p := Strings.Pos (' ', tmpStr, 0);
                   IF p > 0
                   THEN
                     n := Strings.Pos ('@', tmpStr, 0);
                     IF (n-2 < p) & (n > 0)
                     THEN
                       (* Hinter dem @ abschneiden, da kein richtiger Vorname *)
                       tmpStr [n] := 0C;
                     ELSE
                       (* Vornamen verkrzen *)
                       Strings.Delete (tmpStr, 1, p-1, v.bool);
                       Strings.Insert ('.', 1, tmpStr, v.bool);
                     END;
                   END;
                 END;
                 IF LENGTH (tmpStr) > maxLen
                 THEN
                   (* Immer noch zu lang, hinten ... anh„ngen *)
                   FOR i := 1 TO 3 DO
                     tmpStr[maxLen-i] := '.';
                   END;
                   tmpStr[maxLen] := 0C;
                 END;
                 *)
                 Strings.Append (tmpStr, line, v.bool);
                 |
(*
      pRealName  : CheckAssign (mess.name, tmpStr);
                 Strings.Copy (tmpStr, 0, type.w, line, v.bool); |
*)
    pMailId    : CheckAssign (mess.MailID, tmpStr);
                 Strings.Copy (tmpStr, 0, type.w, line, v.bool); |
    pMId       : CheckAssign (mess.mid, tmpStr);
                 Strings.Copy (tmpStr, 0, type.w, line, v.bool); |
    pRefId     : Strings.Copy (mess.KommentierteID, 0, type.w, line, v.bool);
                 IF line[0] # '' THEN Strings.Insert ('-', 0, line, v.bool); END; |
    pWegen     : CheckAssign (mess.Betreff, tmpStr);
                 IF LENGTH (tmpStr) > CARDINAL(type.w)
                 THEN
                   (* Zu lang, hinten ... anh„ngen *)
                   FOR i := 1 TO 3 DO
                     tmpStr[type.w-INTEGER(i)] := '.';
                   END;
                   tmpStr[type.w] := 0C;
                 END;
                 Strings.Assign (tmpStr, line, v.bool); |
    pStatus    : IF ptr^.grHandle^.group = dataSys.private
                 THEN
                   line[0] := mess.Status;
                 ELSE
                   IF dataSys.bGelesen IN mess.StatusBits
                   THEN
                     line[0] := 'G';
                   ELSE
                     line[0] := 'N';
                   END;
                 END;
                 line[1] := 0C; |
    pDatum     : ConvertDate.CatDate2Datim (mess.tauschDate, dt, ti);
                 ConvertDate.DateToText (dt, type.formatStr, line); |
    pTime      : ConvertDate.CatDate2Datim (mess.tauschDate, dt, ti);
                 ConvertDate.TimeToText (ti, type.formatStr, line); |
    pWeekday   : ConvertDate.CatDate2Datim (mess.tauschDate, dt, ti);
                 ConvertDate.DayToText (dt, type.formatStr, line); |
    pFuzzytime : ConvertDate.CatDate2Datim (mess.tauschDate, dt, ti);
                 ConvertDate.FuzzyTime (ti, type.formatStr, line); |
    pComments  : Strings.Assign (StrConv.CardToStr (mess.KommentarAnzahl, type.w), line, v.bool); |
    pCount     : Strings.Assign (StrConv.CardToStr (num+1, 0), line, v.bool);
                 Strings.Insert ('#',0, line, v.bool); |
    pOwnMess   : IF (dataSys.bOwnMessage IN mess.StatusBits)
                 OR (dataSys.bComToOwnMessage IN mess.StatusBits)
                 THEN
                   ch := '*'
                 ELSE
                   ch := ' ';
                 END;
                 FOR i := 0 TO CARDINAL(type.w) - 1 DO
                   line[i] := ch;
                 END;
                 line[type.w] := ''; |
    pLength    : Strings.Assign (StrConv.CardToStr (mess.textLen, 5), line, v.bool);
                 Strings.Append (' Bytes', line, v.bool); |
    pFlags     : Strings.Assign ('-------------', line, v.bool);
                 IF 0 IN mess.StatusBits THEN line[0] := 'L' END;
                 IF 1 IN mess.StatusBits THEN line[1] := 'F' END;
                 IF 2 IN mess.StatusBits THEN line[2] := 'I' END;
                 IF 3 IN mess.StatusBits THEN line[3] := 'T' END;
                 IF 4 IN mess.StatusBits THEN line[4] := 'D' END;
                 IF 5 IN mess.StatusBits THEN line[5] := 'K' END;
                 IF 6 IN mess.StatusBits THEN line[6] := 'B' END;
                 IF 7 IN mess.StatusBits THEN line[7] := '1' END;
                 IF 8 IN mess.StatusBits THEN line[8] := '2' END;
                 IF 9 IN mess.StatusBits THEN line[9] := 'V' END;
                 IF 13 IN mess.StatusBits THEN line[10] := 'C' END;
                 IF 14 IN mess.StatusBits THEN line[11] := 'E' END;
                 IF 15 IN mess.StatusBits THEN line[12] := 'X' END; |

  ELSE
  END;
  Strings.Copy (line, 0, type.w, line, v.bool);
END GetLinePart;

PROCEDURE rawRedraw (ptr : listWdwPtr; clip : GrafBase.Rectangle);
  (* Geht davon aus, daž RectFuncs.ClipRect gesetzt ist und nur Zeilen zu zeichnen sind!
   *)
VAR
    extend : ARRAY [0..3] OF GrafBase.Point;
    i      : INTEGER;
    width  : INTEGER;
    xOutput,
    yOutput: INTEGER;
    xOffset: INTEGER;
    j      : INTEGER;
    topLine: CARDINAL;
    line   : ARRAY [0..1023] OF CHAR;
    entry  : listEntry;
    mess   : data.MessageType;
    myClip : GrafBase.Rectangle;
    fill   : GrafBase.Rectangle;
    attrSet: BOOLEAN;
    isOwn  : BOOLEAN;
BEGIN
  WITH ptr^ DO
    topLine := startPos;
    attrSet := FALSE;
    i := 0;   (* Zeilenz„hler im Fenster *)
    (* Nicht im Redrawbereich liegende Zeilen berspringen *)
    WHILE (topLine <= maxPos) & ((listWork.y + (i+1)*(charHeight+lineDist)) - 1 < clip.y) DO
      INC (topLine);
      INC(i);
    END;
    xOutput := listWork.x + pixOffset - leftOffset;
    yOutput := listWork.y + i * (charHeight + lineDist) + (lineDist DIV 2);
    (* Eintrag in Liste suchen *)
    (* Jetzt zeichnen *)
    myClip := clip;
    v.int := MagicVDI.SetFillcolor (vdi, MagicAES.BLACK);
    v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listTextCol);
    v.int := MagicVDI.SetWritemode (vdi, MagicVDI.TRANSPARENT);
    WHILE (topLine <= maxPos) & (i <= listWork.h DIV (charHeight+lineDist))
          & (yOutput <= clip.h) DO
      entry := list^[topLine];
      (* Header der Message lesen *)
      data.ReadHeader (grHandle^.Zugriff, entry.msgNum, mess);
      IF data.error # data.noError
      THEN
        WITH mess DO
          MailID := NIL;
          Betreff := NIL;
          Absender := NIL;
          Empfaenger := NIL;
          mid := NIL;
          rid := NIL;
          box := NIL;
          name := NIL;
          InfoStrings := NIL;
        END;
      END;
      (* Erstmal Flag in Liste updaten *)
      IF dataSys.bGelesen IN mess.StatusBits
      THEN
        EXCL (list^[topLine].flags, notRead);
      ELSE
        INCL (list^[topLine].flags, notRead);
      END;
      (* Testen, ob Gelesen-Flag ver„ndert wurde *)
      IF ((dataSys.bGelesen IN mess.StatusBits) # ~(notRead IN entry.flags))
       & (firstRead IN entry.flags)
      THEN
        (* Eintrag muž komplett neu gezeichnet werden *)
        INCL (list^[topLine].flags, doRedraw);
      END;
      INCL (list^[topLine].flags, firstRead);
      (* Jetzt die einzelnen Zeilenteile ausgeben *)
      (* Nicht gelesene werden fett dargestellt *)
      isOwn := (dataSys.bComToOwnMessage IN mess.StatusBits) OR
               (dataSys.bOwnMessage IN mess.StatusBits) OR
               ((grHandle^.group = dataSys.private) & mess.EigeneNachricht);
      IF ~(dataSys.bGelesen IN mess.StatusBits) (* & ~attrSet *)
      THEN
        IF mtAppl.Bitplanes = 1 THEN
          IF isOwn
          THEN
            v.bset := MagicVDI.SetTexteffect (vdi, quoteEff+ownEff);
          ELSE
            v.bset := MagicVDI.SetTexteffect (vdi, quoteEff);
          END;
        ELSE
          IF isOwn
          THEN
            v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listOwnCol);
          ELSE
            v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listUnreadCol);
          END;
        END;
        attrSet := TRUE;
      ELSIF (dataSys.bGelesen IN mess.StatusBits) (* & attrSet *)
      THEN
        IF isOwn
        THEN
          IF mtAppl.Bitplanes = 1
          THEN
            v.bset := MagicVDI.SetTexteffect (vdi, ownEff);
          ELSE
            v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listOwnCol);
          END;
        ELSE
          v.bset := MagicVDI.SetTexteffect (vdi, {});
          v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listTextCol);
        END;
        attrSet := FALSE;
      END;
      xOffset := 0;
      FOR j := 0 TO partArray.lines-1 DO
        GetLinePart (ptr, entry.msgNum, mess, line, partArray.parts[j]);
        width := partArray.parts[j].w * charWidth;
        myClip.w := BinOps.LowerInt (clip.w, xOutput + xOffset + width);
        IF (myClip.w >= clip.x) & (xOutput+xOffset <= myClip.w)
        THEN
          (* WdwManager.SetClip (vdi, myClip, FALSE); *)
          VDIStandards.Text (isFSM, vdi, xOutput+xOffset, yOutput+charHeight-1, line);
        END;
        INC (xOffset, width + charWidth);
      END;
      IF Selected IN entry.flags
      THEN
        (*
        WdwManager.SetClip (vdi, clip, FALSE);
        *)
        fill.x := xOutput;
        fill.y := yOutput;
        fill.w := xOutput + xOffset - 1;
        fill.h := yOutput + charHeight - 1;
        (* Schreibmodus setzen *)
        v.int := MagicVDI.SetWritemode (vdi, MagicVDI.XOR);
        MagicVDI.FillRectangle(vdi, fill);
        v.int := MagicVDI.SetWritemode (vdi, MagicVDI.TRANSPARENT);
(*        v.int := MagicVDI.SetWritemode (vdi, MagicVDI.REPLACE); *)
      END;
      entryWidth := xOffset;
      maxWidth := BinOps.HigherInt (maxWidth, xOffset+pixOffset);
      IF mess.InfoStrings # NIL THEN
        DEALLOCATE (mess.InfoStrings, 0);
      END;
      IF (cursPos >= 0) & (LONGINT(LONG(topLine)) = cursPos)
      THEN
        drawCursor (ptr);
        v.int := MagicVDI.SetFillcolor (vdi, MagicAES.BLACK);
      END;
      INC(i);
      INC (topLine);
      INC (yOutput, charHeight+lineDist);
    END;
    v.int := MagicVDI.SetFillcolor (vdi, CatGlobal.listBackCol);
    IF attrSet THEN
      IF mtAppl.Bitplanes = 1 THEN
        v.bset := MagicVDI.SetTexteffect (vdi, {});
      ELSE
        v.int := MagicVDI.SetTextcolor (vdi, CatGlobal.listTextCol);
      END;
    END;
  END (* WITH ptr *);
END rawRedraw;


PROCEDURE shrinkToEnd (ptr: listWdwPtr; doRedraw: BOOLEAN);
  VAR i, j     : CARDINAL;
      allocNew : BOOLEAN;
      oldList  : listArrayPtr;
      start    : CARDINAL;
BEGIN
  WITH ptr^ DO
    IF startPos = 0 THEN RETURN END;
    IF startPos > maxPos THEN HALT END;
    IF wholeList = list
    THEN
      list := NIL;
      ALLOCATE (list, LONG(maxPos - startPos + 1) * TSIZE (listEntry));
      IF list = NIL
      THEN
        MTE.noMemAlert();
        RETURN
      END;
      allocNew := TRUE;
      oldList := wholeList;
    ELSE
      oldList := list;
      allocNew := FALSE;
    END;
    (* Erstmal neue Startposition festlegen *)
    start := oldList^[startPos].msgNum;
    (* Und jetzt die Liste verkleinern *)
    j := 0;
    FOR i := startPos TO maxPos DO
      list^[j] := oldList^[i];
      INC (j);
    END;
    IF ~allocNew
    THEN
      (* Speicherbereich verkleinern *)
      DEALLOCATE (list, LONG (startPos) * TSIZE (listEntry));
    END;
    (* neue maxPos festlegen *)
    maxPos := maxPos - startPos;
    findMsgIdx (ptr, start, startPos);
    startPos := BinOps.LowerCard (startPos, maxPos);
    cursPos := -1;
    IF doRedraw
    THEN
      (* Neues Document setzen *)
      WdwManager.SetNewDocument (wdw, GrafBase.LongRect{LONG(leftOffset), startPos, LONG(maxWidth), maxPos}, FALSE);
      WdwManager.FullRedrawWdw (wdw);
    END;
  END;
END shrinkToEnd;

PROCEDURE shrinkList (ptr: listWdwPtr; removeSel : BOOLEAN; doRedraw: BOOLEAN): BOOLEAN;
(* removes the selected messages from the list *)
  VAR firstSel : CARDINAL;
      count    : CARDINAL;
      i, j     : CARDINAL;
      allocNew : BOOLEAN;
      oldList  : listArrayPtr;
      start    : CARDINAL;
BEGIN
  WITH ptr^ DO
    IF hasSelectedEntries (ptr, firstSel)
    THEN
      count := countSelectedEntries (ptr);
      IF (count = 0) OR (count = maxPos + 1) THEN
        IF removeSel THEN
          MTE.info (MTE.emptyList);
        END;
        RETURN TRUE
      END;
      (* Erstmal neue Startposition festlegen *)
      IF ~removeSel
      THEN
        (* n„chste selektierte suchen *)
        IF ~(Selected IN list^[startPos].flags)
        THEN
          start := FindNextSelected (ptr, list^[startPos].msgNum);
          IF start > maxPos
          THEN
            start := FindPrevSelected (ptr, list^[startPos].msgNum);
          END;
        ELSE
          start := list^[startPos].msgNum;
        END;
      ELSIF removeSel
      THEN
        IF Selected IN list^[startPos].flags
        THEN
          start := FindNextDeselected (ptr, list^[startPos].msgNum);
          IF start > maxPos
          THEN
            start := FindPrevDeselected (ptr, list^[startPos].msgNum);
          END;
        ELSE
          start := list^[startPos].msgNum;
        END;
      END;
      IF wholeList = list
      THEN
        list := NIL;
        IF removeSel
        THEN
          ALLOCATE (list, LONG(maxPos - count + 1) * TSIZE (listEntry));
        ELSE
          ALLOCATE (list, LONG(count) * TSIZE (listEntry));
        END;
        IF list = NIL
        THEN
          MTE.noMemAlert();
          RETURN FALSE
        END;
        allocNew := TRUE;
        oldList := wholeList;
      ELSE
        oldList := list;
        allocNew := FALSE;
      END;
      (* Und jetzt die Liste verkleinern *)
      j := 0;
      FOR i := 0 TO maxPos DO
        IF (removeSel & ~(Selected IN oldList^[i].flags))
        OR (~removeSel & (Selected IN oldList^[i].flags))
        THEN
          list^[j] := oldList^[i];
          INC (j);
        END;
      END;
      IF ~allocNew
      THEN
        (* Speicherbereich verkleinern *)
        IF removeSel
        THEN
          DEALLOCATE (list, LONG(count) * TSIZE (listEntry));
        ELSE
          DEALLOCATE (list, LONG (maxPos+1-count) * TSIZE (listEntry));
        END;
      END;
      IF removeSel
      THEN
        maxPos := maxPos - count;
      ELSE
        maxPos := count - 1;
      END;
      findMsgIdx (ptr, start, startPos);
      (* startPos := BinOps.LowerCard (startPos, maxPos); *)
      IF startPos > maxPos THEN startPos := 0 END;
      IF startPos + CARDINAL(windLines) > maxPos THEN
        IF CARDINAL(windLines) > maxPos
        THEN
          startPos := 0
        ELSE
          startPos := maxPos - CARDINAL(windLines);
        END;
      END;
      cursPos := -1;
      (* Neues Document setzen *)
      IF doRedraw
      THEN
        WdwManager.SetNewDocument (wdw, GrafBase.LongRect{LONG(leftOffset), startPos, LONG(maxWidth), maxPos}, FALSE);
        WdwManager.FullRedrawWdw (wdw);
      END;
      RETURN TRUE
    END;
    RETURN FALSE
  END;
END shrinkList;

PROCEDURE showAll (ptr : listWdwPtr);
  VAR start : CARDINAL;
BEGIN
  WITH ptr^ DO
    IF list # wholeList
    THEN
      start := list^[startPos].msgNum;
      (* deallocate list *)
      DEALLOCATE (list, 0);
      list := wholeList;
      maxPos := data.LastMsgOfGroup (grHandle^.group);
      findMsgIdx (ptr, start, startPos);
      startPos := BinOps.LowerCard (startPos, maxPos);
      cursPos := -1;
      WdwManager.SetNewDocument (wdw, GrafBase.LongRect{LONG(leftOffset), startPos, LONG(maxWidth), maxPos}, FALSE);
      WdwManager.FullRedrawWdw (wdw);
    END;
  END;
END showAll;

(*$H+*)
PROCEDURE selectTree (ptr: listWdwPtr; doRedraw: BOOLEAN);
  VAR firstSel : CARDINAL;
      i        : CARDINAL;

  (*$H+*)
  PROCEDURE selTree (handle: data.OneGroupHandle;
                     msgIdx: CARDINAL;
                     mess  : dataSys.pBlockPtr);
    VAR i : CARDINAL;
  BEGIN
    (* search for mess *)
    WITH ptr^ DO
      (* First try normal list *)
      IF (msgIdx <= maxPos) & (list^[msgIdx].msgNum = msgIdx)
      THEN
        INCL (list^[msgIdx].flags, Selected);
        EXCL (list^[msgIdx].flags, inTree);
        RETURN
      END;
      (* Not found, search from end *)
      i := maxPos;
      WHILE (list^[i].msgNum # msgIdx) & (i > 0) DO DEC (i) END;
      IF list^[i].msgNum = msgIdx
      THEN
        INCL (list^[i].flags, Selected);
        EXCL (list^[i].flags, inTree);
      END;
    END;
  END selTree;

BEGIN
  WITH ptr^ DO
    IF hasSelectedEntries (ptr, firstSel)
    THEN
      (* Fr alle selektierten Nachrichten das inTree-Flag setzen *)
      FOR i := firstSel TO maxPos DO
        IF (Selected IN list^[i].flags) THEN
          INCL (list^[i].flags, inTree);
        END;
      END;
      FOR i := firstSel TO maxPos DO
        IF (inTree IN list^[i].flags) THEN
          (* Alle Nachrichten im Baum selektieren *)
          data.WalkTree (grHandle^.Zugriff, list^[i].msgNum, TRUE, selTree);
        END;
      END;
      IF doRedraw
      THEN
        (* Alles neuzeichnen *)
        WdwManager.FullRedrawWdw (wdw);
      END;
    END;
  END;
END selectTree;

PROCEDURE selectFromTop (ptr: listWdwPtr);
  VAR i : CARDINAL;
BEGIN
  WITH ptr^ DO
    FOR i := startPos TO maxPos DO
      INCL (list^[i].flags, Selected);
    END;
    WdwManager.FullRedrawWdw (wdw);
  END;
END selectFromTop;

PROCEDURE removeTree (ptr: listWdwPtr);
  VAR firstSel : CARDINAL;
BEGIN
  WITH ptr^ DO
    IF hasSelectedEntries (ptr, firstSel)
    THEN
      (* ok, ready, set, go *)
      selectTree (ptr, FALSE);
      (* And now remove selected *)
      IF ~shrinkList (ptr, TRUE, TRUE)
      THEN
        (* Redraw wird schon in shrinkList gemacht, wenn TRUE zurckkommt *)
        WdwManager.FullRedrawWdw (wdw);
      END;
    END;
  END;
END removeTree;

PROCEDURE listSelectFiltered(wdw : INTEGER; doSelect: BOOLEAN; doRedraw: BOOLEAN);
(* Alle Nachrichten in dem Fenster werden selektiert *)
  VAR p : listWdwPtr;
      i : CARDINAL;
      bits : BITSET;
BEGIN
  IF handlePool.FindEntry(ADR(wdw), FindWinCond, windows, p) THEN
    WITH p^ DO
      CatGlobal.busyMouse();
      FOR i := 0 TO maxPos DO
        data.ReadState (grHandle^.Zugriff, list^[i].msgNum, bits);
        IF dataSys.bFiltered IN bits THEN
          IF doSelect
          THEN
            INCL (list^[i].flags, Selected);
          ELSE
            EXCL (list^[i].flags, Selected);
          END;
        END;
        IF (i MOD 75) = 0 THEN
          CatGlobal.busyMouse();
        END;
      END;
      mtAppl.MouseArrow();
    END;
    IF doRedraw
    THEN
      (* Und jetzt vorsichtshalber Redraw ausl”sen *)
      WdwManager.FullRedrawWdw (wdw);
    END;
  END;
END listSelectFiltered;

PROCEDURE openSelected (ptr : listWdwPtr; doNotTop: BOOLEAN; withCtrl : BOOLEAN);
  VAR firstSel : CARDINAL;
      isOpen   : BOOLEAN;
      nextMsg  : grin.grinNextMessProc;
      window   : INTEGER;
      group,
      mess     : CARDINAL;
      i        : CARDINAL;
      bits     : BITSET;
BEGIN
  WITH ptr^ DO
    IF hasSelectedEntries (ptr, firstSel)
    THEN
      IF countSelectedEntries (ptr) > 1
      THEN
        nextMsg := listNextMess;
        (* Jetzt vorarbeiten fr Gelesene ignorieren *)
        FOR i := firstSel TO maxPos DO
          IF (Selected IN list^[i].flags)
          THEN
            (* Statusbits lesen *)
            data.ReadState (grHandle^.Zugriff, list^[i].msgNum, bits);
            IF dataSys.bGelesen IN bits
            THEN
              INCL (list^[i].flags, initRead);
            ELSE
              EXCL (list^[i].flags, initRead);
            END;
          ELSE
            EXCL (list^[i].flags, initRead);
          END;
        END;
      ELSE
        nextMsg := grin.grinNextMess;
      END;
      isOpen := FALSE;
      IF (grinWindow >= 0) & ~withCtrl
      THEN
        IF grin.grinWindowTop (grinWindow) &
          (grin.ActualGroupNr (grinWindow) = grHandle^.group)
        THEN
          isOpen := grin.grinSwitchTo (grinWindow, list^[firstSel].msgNum, nextMsg, LONGCARD(ptr), doNotTop);
          IF isOpen
          THEN
            IF usedByGrin = 0 THEN INC (usedByGrin) END;
          END;
        ELSE
          grinWindow := -1;
        END;
      END;
      IF ~isOpen
      THEN
        INC(usedByGrin);
        window := grin.grinOpenMessage (grHandle^.group, list^[firstSel].msgNum, nextMsg, LONGCARD(ptr), openMode);
        (* Nun Anfragen, welches Grinfenster nun top ist *)
        IF (window >= 0) & grin.grinWindowTop (window)
         & grin.getBasicInfo (window, group, mess, v.lcard)
         & (group = grHandle^.group) & (mess = list^[firstSel].msgNum)
        THEN
          grinWindow := window;
        END;
      END;
    END;
  END;
END openSelected;

PROCEDURE freeList (ptr : listWdwPtr);
BEGIN
  WITH ptr^ DO
    IF list # NIL THEN
      IF (list # wholeList)
      THEN
        DEALLOCATE (list, 0);
        list := NIL;
      END;
      DEALLOCATE (wholeList, 0);
      wholeList := NIL;
    END;
  END;
END freeList;

PROCEDURE testBreak (): BOOLEAN;
VAR char, scan : CHAR; kstate : BITSET;
BEGIN
  IF VDIUtil.isKey(kstate, scan, char) & (char = 33C)
  THEN
    v.int := mtAlerts.Alert (2, MTE.sortBreak);
    RETURN v.int = 1;
  END;
  RETURN FALSE
END testBreak;

VAR ignoreCase: BOOLEAN;

PROCEDURE strCmp (REF s1, s2: ARRAY OF CHAR): MagicStrings.Relation;
BEGIN
  IF ignoreCase
  THEN
    RETURN AssFuncs.StrICompare (s1, s2);
  ELSE
    RETURN MagicStrings.Compare (s1, s2);
  END
END strCmp;

PROCEDURE nameCompare (REF str1, str2: ARRAY OF CHAR): MagicStrings.Relation;
  VAR n1, n2 : CatTypes.String255;
      p1, p2 : INTEGER;
      x1, x2 : INTEGER;
      v1, v2 : CatTypes.String255;
      r      : MagicStrings.Relation;
BEGIN
  (* Erstmal Nachnamen suchen *)
  p1 := Strings.Pos (' ', str1, 0);
  IF p1 > 0
  THEN
    Strings.Copy (str1, 0, p1, v1, v.bool);
    Strings.Copy (str1, p1+1, INTEGER(LENGTH (str1)) - p1 - 1, n1, v.bool);
    (* Noch nach @ suchen und abschneiden! *)
    x1 := Strings.Pos ('@', n1, p1);
    IF x1 > 0
    THEN
      n1[x1] := 0c;
    END;
  END;
  p2 := Strings.Pos (' ', str2, 0);
  IF p2 > 0
  THEN
    Strings.Copy (str2, 0, p2, v2, v.bool);
    Strings.Copy (str2, p2+1, INTEGER(LENGTH (str2)) - p2 - 1, n2, v.bool);
    x2 := Strings.Pos ('@', n2, p2);
    IF x2 > 0
    THEN
      n2[x2] := 0c;
    END;
  END;
  IF (p1 > 0) & (p2 > 0)
  THEN
    (* Und jetzt k”nnen wir vergleichen *)
    r := strCmp (n1, n2);
    IF r = MagicStrings.equal
    THEN
      RETURN strCmp (v1, v2);
    END;
    RETURN r
  ELSIF (p1 > 0)
  THEN
    (* Vergleich von Nachnamen mit Namen *)
    r := strCmp (n1, str2);
    IF r = MagicStrings.equal
    THEN
      (* Vergleich von Vornamen mit Namen *)
      RETURN strCmp (v1, str2);
    END;
    RETURN r
  ELSIF (p2 > 0)
  THEN
    (* Vergleich von Nachnamen mit Namen *)
    r := strCmp (str1, n2);
    IF r = MagicStrings.equal
    THEN
      (* Vergleich von Vornamen mit Namen *)
      RETURN strCmp (str1, v2);
    END;
    RETURN r
  END;
  RETURN strCmp (str1, str2);
END nameCompare;


(*$H+*)
PROCEDURE doSort(VAR ptr : listWdwPtr; sort: sortType; withRedraw: BOOLEAN);
  VAR start, end : CARDINAL;
      i          : CARDINAL;
      cmpCount   : LONGCARD;

  PROCEDURE compNum (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    RETURN x^.msgNum < y^.msgNum
  END compNum;

  PROCEDURE compTree (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    IF x^.treeNum = y^.treeNum
    THEN
      RETURN x^.msgNum < y^.msgNum
    ELSE
      RETURN x^.treeNum < y^.treeNum;
    END;
  END compTree;

  PROCEDURE compSize (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
        mess1: data.MessageType;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    IF x^.treeNum = 0
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, x^.msgNum, mess1);
      x^.treeNum := LONG (mess1.textLen);
      DEALLOCATE (mess1.InfoStrings, 0);
    END;
    IF y^.treeNum = 0
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, y^.msgNum, mess1);
      y^.treeNum := LONG (mess1.textLen);
      DEALLOCATE (mess1.InfoStrings, 0);
    END;
    IF x^.treeNum = y^.treeNum
    THEN
      RETURN x^.msgNum < y^.msgNum
    ELSE
      (* Grože Nachrichten zuerst! *)
      RETURN x^.treeNum > y^.treeNum;
    END;
  END compSize;

  PROCEDURE compDate (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
        mess1: data.MessageType;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    IF x^.treeNum = 0
    THEN
      data.ReadSmallHeader (ptr^.grHandle^.Zugriff, x^.msgNum, mess1);
      x^.treeNum := mess1.tauschDate;
      (* DEALLOCATE (mess1.InfoStrings, 0); *)
    END;
    IF y^.treeNum = 0
    THEN
      data.ReadSmallHeader (ptr^.grHandle^.Zugriff, y^.msgNum, mess1);
      y^.treeNum := mess1.tauschDate;
      (* DEALLOCATE (mess1.InfoStrings, 0); *)
    END;
    IF x^.treeNum = y^.treeNum
    THEN
      RETURN x^.msgNum < y^.msgNum
    ELSE
      RETURN x^.treeNum < y^.treeNum;
    END;
  END compDate;

  PROCEDURE compName (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
        mess1,
        mess2: data.MessageType;
        comp : MagicStrings.Relation;
        str1, str2 : CatTypes.String255;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    IF x^.strPtr = NIL
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, x^.msgNum, mess1);
      IF mess1.EigeneNachricht & (mess1.Gruppe = dataSys.private)
      THEN
        MagicStrings.Assign (mess1.Empfaenger^, str1);
      ELSE
        MagicStrings.Assign (mess1.Absender^, str1);
      END;
      DEALLOCATE (mess1.InfoStrings, 0);
      ALLOCATE (x^.strPtr, LENGTH (str1)+2);
      IF x^.strPtr # NIL
      THEN
        MagicStrings.Assign (str1, x^.strPtr^);
      END;
    ELSE
      MagicStrings.Assign (x^.strPtr^, str1);
    END;
    IF y^.strPtr = NIL
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, y^.msgNum, mess2);
      IF mess2.EigeneNachricht & (mess2.Gruppe = dataSys.private)
      THEN
        MagicStrings.Assign (mess2.Empfaenger^, str2);
      ELSE
        MagicStrings.Assign (mess2.Absender^, str2);
      END;
      DEALLOCATE (mess2.InfoStrings, 0);
      ALLOCATE (y^.strPtr, LENGTH (str2)+2);
      IF y^.strPtr # NIL
      THEN
        MagicStrings.Assign (str2, y^.strPtr^);
      END;
    ELSE
      MagicStrings.Assign (y^.strPtr^, str2)
    END;
    comp := nameCompare (str1, str2);
    IF comp = MagicStrings.equal
    THEN
      RETURN x^.msgNum < y^.msgNum
    ELSE
      RETURN comp = MagicStrings.less
    END;
  END compName;

  PROCEDURE compWegen (e1, e2 : ADDRESS): BOOLEAN;
    VAR x, y : listEntryPtr;
        mess1,
        mess2: data.MessageType;
        comp : MagicStrings.Relation;
        erg  : BOOLEAN;
        str1, str2 : CatTypes.String255;
        hasRe1,
        hasRe2: BOOLEAN;
        tmp  : ARRAY [0..4] OF CHAR;
  BEGIN
    IF cmpCount MOD 25 = 0 THEN CatGlobal.busyMouse() END;
    INC (cmpCount);
    x := listEntryPtr (e1);
    y := listEntryPtr (e2);
    IF x^.strPtr = NIL
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, x^.msgNum, mess1);
      MagicStrings.Assign (mess1.Betreff^, str1);
      DEALLOCATE (mess1.InfoStrings, 0);
      ALLOCATE (x^.strPtr, LENGTH (str1)+2);
      IF x^.strPtr # NIL
      THEN
        MagicStrings.Assign (str1, x^.strPtr^);
      END;
    ELSE
      MagicStrings.Assign (x^.strPtr^, str1);
    END;
    IF y^.strPtr = NIL
    THEN
      data.ReadHeader (ptr^.grHandle^.Zugriff, y^.msgNum, mess2);
      MagicStrings.Assign (mess2.Betreff^, str2);
      DEALLOCATE (mess2.InfoStrings, 0);
      ALLOCATE (y^.strPtr, LENGTH (str2)+2);
      IF y^.strPtr # NIL
      THEN
        MagicStrings.Assign (str2, y^.strPtr^);
      END;
    ELSE
      MagicStrings.Assign (y^.strPtr^, str2)
    END;
    hasRe1 := FALSE;
    hasRe2 := FALSE;
    Strings.Copy (str1, 0, 3, tmp, v.bool);
    IF AssFuncs.StrIequal (tmp, "RE:")
    THEN
      Strings.Delete (str1, 0, 3, v.bool);
      Strings.DelLeadingBlanks (str1);
      hasRe1 := TRUE;
    END;
    Strings.Copy (str2, 0, 3, tmp, v.bool);
    IF AssFuncs.StrIequal (tmp, "RE:")
    THEN
      Strings.Delete (str2, 0, 3, v.bool);
      Strings.DelLeadingBlanks (str2);
      hasRe2 := TRUE;
    END;
    comp := strCmp (str1, str2);
    IF comp = MagicStrings.equal
    THEN
      IF hasRe1 & ~hasRe2
      THEN
        RETURN FALSE
      ELSIF ~hasRe1 & hasRe2
      THEN
        RETURN TRUE
      END;
      erg := x^.msgNum < y^.msgNum
    ELSE
      erg := comp = MagicStrings.less
    END;
    RETURN erg;
  END compWegen;

  PROCEDURE prepareTreeSort ();
    VAR tree : LONGCARD;
        j    : CARDINAL;

  PROCEDURE markTree (handle: data.OneGroupHandle;
                     msgIdx: CARDINAL;
                     mess  : dataSys.pBlockPtr);
    VAR i : CARDINAL;
  BEGIN
    (* search for mess *)
    WITH ptr^ DO
      (* First try normal list *)
      IF (msgIdx < maxPos) & (list^[msgIdx].msgNum = msgIdx)
      THEN
        list^[msgIdx].treeNum := tree;
        RETURN
      END;
      (* Not found, search from end *)
      i := end;
      WHILE (list^[i].msgNum # msgIdx) & (i > start) DO DEC (i) END;
      IF list^[i].msgNum = msgIdx
      THEN
        list^[i].treeNum := tree;
      END;
    END;
  END markTree;

  BEGIN
    WITH ptr^ DO
      tree := 1;
      FOR j := start TO end DO
        (* Alle durchgehen *)
        IF list^[j].treeNum = 0
        THEN
          CatGlobal.busyMouse();
          data.WalkTree (grHandle^.Zugriff, list^[j].msgNum, TRUE, markTree);
          INC (tree);
        END;
      END;
    END;
  END prepareTreeSort;

BEGIN
  WITH ptr^ DO
    start := startPos;
    end := maxPos;
    IF (start >= dataSys.notSaved) OR (end >= dataSys.notSaved) THEN RETURN END;
    IF (sort # sTree) & (sort # sSize) & (sort # sDate)
    THEN
      FOR i := start TO end DO
        list^[i].strPtr := NIL
      END;
    ELSE
      FOR i := start TO end DO
        list^[i].treeNum := 0
      END;
    END;
    cmpCount := 0;
    ConfVars.GetConfDefBool (cListCase, ignoreCase, FALSE);
    CASE sort OF
      sVon   : v.bool := QuickSort.sortIt (start, end, list^, compName, TSIZE (listEntry), testBreak); |
      sWegen : v.bool := QuickSort.sortIt (start, end, list^, compWegen, TSIZE (listEntry), testBreak); |
      sTree  : prepareTreeSort();
               v.bool := QuickSort.sortIt (start, end, list^, compTree, TSIZE (listEntry), testBreak); |
      sNum   : v.bool := QuickSort.sortIt (start, end, list^, compNum, TSIZE (listEntry), testBreak); |
      sSize  : v.bool := QuickSort.sortIt (start, end, list^, compSize, TSIZE (listEntry), testBreak); |
      sDate  : v.bool := QuickSort.sortIt (start, end, list^, compDate, TSIZE (listEntry), testBreak); |
    ELSE
    END;
    (* Allozierten Speicher wieder freigeben *)
    IF (sort # sTree) & (sort # sSize) & (sort # sDate)
    THEN
      FOR i := start TO end DO
        IF list^[i].strPtr # NIL THEN DEALLOCATE (list^[i].strPtr, 0) END;
      END;
    END;
    IF withRedraw
    THEN
      WdwManager.FullRedrawWdw (wdw);
    END;
    mtAppl.MouseArrow();
  END;
END doSort;
(*$H=*)

PROCEDURE doMark(ptr : listWdwPtr; withDial: BOOLEAN);
  VAR mode   : INTEGER;
      what   : data.SearchSet;
      start,
      nr, idx: CARDINAL;
      break  : BOOLEAN;
      kstate : BITSET;
      char,
      scan   : CHAR;

BEGIN
  WITH ptr^ DO
    IF withDial THEN
      mode := ZSearchDial.DoSearchDial (TRUE);
      IF mode < 0 THEN RETURN END;
    ELSE
      mode := ZSearchDial.FASTAHEAD
    END;
    IF SearchHelp.suchVar.searchStr[0, 0] = 0C THEN
      SearchHelp.suchVar.searchText := FALSE;
    END;
    what := data.SearchSet{};
    IF SearchHelp.suchVar.statussearch THEN INCL(what, data.inBits) END;
    IF SearchHelp.suchVar.searchText   THEN INCL(what, data.inText) END;
    IF SearchHelp.suchVar.change       THEN INCL(what, data.changeBits) END;
    IF mode = ZSearchDial.FASTBACK
    THEN
      INCL (what, data.reverse);
      (* Startmessage suchen *)
      start := 0;
      FOR idx := 0 TO startPos DO
        start := BinOps.HigherCard (start, list^[idx].msgNum);
      END;
    ELSE
      (* Startmessage suchen *)
      start := dataSys.empty;
      FOR idx := startPos TO maxPos DO
        start := BinOps.LowerCard (start, list^[idx].msgNum);
      END;
    END;
    CatGlobal.busyMouse();
    nr := 1;
    break := FALSE;
    WHILE (nr < dataSys.notSaved) & ~break
       &  data.ComplexSearch (grHandle^.Zugriff,
                              start,
                              SearchHelp.suchVar.sSetBits,
                              SearchHelp.suchVar.sClearedBits,
                              SearchHelp.suchVar.searchStr[0],
                              SearchHelp.suchVar.searchStr[1],
                              SearchHelp.suchVar.searchStr[2],
                              SearchHelp.suchVar.searchStr[3],
                              SearchHelp.suchVar.wo[0],
                              SearchHelp.suchVar.wo[1],
                              SearchHelp.suchVar.wo[2],
                              SearchHelp.suchVar.wo[3],
                              SearchHelp.suchVar.verkn[0],
                              SearchHelp.suchVar.verkn[1],
                              SearchHelp.suchVar.verkn[2],
                              SearchHelp.suchVar.gross,
                              SearchHelp.suchVar.setBits,
                              SearchHelp.suchVar.clearBits,
                              what,
                              v.bool,
                              nr) DO
      IF nr < dataSys.notSaved
      THEN
        findMsgIdx (ptr, nr, idx);
        IF idx < dataSys.notSaved
        THEN
          IF mode = ZSearchDial.FASTBACK
          THEN
            IF idx <= startPos
            THEN
              INCL(list^[idx].flags, Selected);
            END;
          ELSE
            IF idx >= startPos
            THEN
              INCL(list^[idx].flags, Selected);
            END;
          END;
        END;
        IF mode # ZSearchDial.FASTBACK
        THEN
          start := nr+1;
        ELSE
          IF (nr > 0 ) THEN start := nr - 1;
          ELSE
            nr := dataSys.empty;
          END;
        END;
      END;
    END;
    IF withDial
    THEN
      WdwManager.FullRedrawWdw (wdw);
    END;
    mtAppl.MouseArrow();
  END;
END doMark;

PROCEDURE redrawButton (wdw: INTEGER; butBox: mtUtils.tObjcTree; ob: INTEGER);
  VAR r : GrafBase.Rectangle;
BEGIN
  mtUtils.CalcArea (butBox, ob, r);
  WdwManager.RedrawWdw (wdw, r);
END redrawButton;

PROCEDURE careForSelected (ptr: listWdwPtr; redraw: BOOLEAN);
  CONST cSel        = ' selektiert';
        cNachricht  = ' Nachricht';
        cPlural     = 'en';
        cVon        = ' von ';
  VAR sels: CARDINAL;
      str : CatTypes.String127;
BEGIN
  WITH ptr^ DO
    sels := countSelectedEntries(ptr);
    MagicStrings.Assign ('', str);
    IF sels > 0
    THEN
      MagicStrings.Append (StrConv.CardToStr (sels, 0), str);
      MagicStrings.Append (cVon, str);
    END;
    MagicStrings.Append (StrConv.CardToStr (maxPos+1, 0), str);
    MagicStrings.Append (cNachricht, str);
    IF maxPos > 0
    THEN
      MagicStrings.Append (cPlural, str);
    END;
    IF sels > 0
    THEN
      MagicStrings.Append (cSel, str);
    END;
    (*
    (* Nur fr Test: *)
    MagicStrings.Append (', ptr^.usedByGrin: ', str);
    MagicStrings.Append (StrConv.IntToStr (ptr^.usedByGrin, 0), str);
    *)
    mtUtils.SetObjcString (butBox, MausTauschrsc.listtext, str);
    IF redraw THEN
      redrawButton (wdw, butBox, MausTauschrsc.listtext);
    END;
  END;
END careForSelected;

PROCEDURE drawListWdw (wdw, vdiH : INTEGER; special : ADDRESS; frame : GrafBase.Rectangle);
VAR clip : GrafBase.Rectangle;
    ptr  : listWdwPtr;
    oldMax : INTEGER;
    eff  : INTEGER;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    IF isLocked THEN RETURN END;
    CASE CatGlobal.listUnreadEff OF
      0 : quoteEff := {}; |
      1 : quoteEff := {MagicVDI.Fat}; |
      2 : quoteEff := {MagicVDI.Italic}; |
      3 : quoteEff := {MagicVDI.Light}; |
    ELSE
      quoteEff := {};
    END;
    CASE CatGlobal.listOwnEff OF
      0 : ownEff := {}; |
      1 : ownEff := {MagicVDI.Fat}; |
      2 : ownEff := {MagicVDI.Italic}; |
      3 : ownEff := {MagicVDI.Light}; |
    ELSE
      ownEff := {};
    END;
    IF (mtAppl.Bitplanes = 1)
    THEN
      CatGlobal.listUnreadCol := CatGlobal.listTextCol;
      CatGlobal.listOwnCol := CatGlobal.listTextCol;
      IF (CatGlobal.listTextCol > 0)
      THEN
        CatGlobal.listBackCol := 0;
      ELSE
        CatGlobal.listBackCol := 1;
      END;
    END;
    WdwManager.GetWdwWork (wdw, clip);
    AdjustTreePos (clip, butWork);
    clip := frame;
    IF RectFuncs.rcIntersect (butWork, clip)
    THEN
      careForSelected (ptr, FALSE);
      VDIUtil.SetTreeColor (butBox, CatGlobal.listTextCol, CatGlobal.listBackCol);
      mtDials.DialDraw (butBox, 0, 8, clip, TRUE);
      mtAppl.MouseOff();
    END;
    clip := frame;
    IF RectFuncs.rcIntersect (listWork, clip)
    THEN
      oldMax := maxWidth;
      clip := RectFuncs.ClipRect (frame, listWork);
      clip.w := clip.x + clip.w - 1;
      clip.h := clip.y + clip.h -1;

      v.int := MagicVDI.SetFillcolor (vdi, CatGlobal.listBackCol);
      MagicVDI.FillRectangle(vdi, clip);

      IF clip.x = listWork.x THEN
        INC (clip.x, pixOffset);
      END;

      clip.x := BinOps.LowerInt (clip.x, clip.w);

      WdwManager.SetClip (vdi, clip, FALSE);

      rawRedraw (ptr, clip);

      IF oldMax # maxWidth THEN
        WdwManager.SetWdwDocument (wdw, GrafBase.LongRect{LONG(leftOffset), startPos, LONG(maxWidth), maxPos});
      END;
    END;
  END (* WITH ptr^ DO *);
END drawListWdw;

PROCEDURE checkPopups(selected: CARDINAL);
  VAR isReg : BOOLEAN;
BEGIN
  mtUtils.SetState (selPop, MausTauschrsc.lseltree, MagicAES.DISABLED, (selected = 0));
  mtUtils.SetState (removePop, MausTauschrsc.lremsel, MagicAES.DISABLED, (selected = 0));
  mtUtils.SetState (removePop, MausTauschrsc.lremnsel, MagicAES.DISABLED, (selected = 0));
  mtUtils.SetState (removePop, MausTauschrsc.lrembaum, MagicAES.DISABLED, (selected = 0));
END checkPopups;

PROCEDURE handleButtons (ptr : listWdwPtr; ob : INTEGER; kstate: BITSET) : BOOLEAN;
  VAR
      i      : INTEGER;
      select : INTEGER;
      selectCount : CARDINAL;
      x, y   : INTEGER;

BEGIN
  WITH ptr^ DO
    IF ~mtUtils.InState (butBox, ob, MagicAES.DISABLED)
      & mtUtils.InFlag (butBox, ob, MagicAES.SELECTABLE)
    THEN
      (* Button selektieren *)
      mtUtils.InclState (butBox, ob, MagicAES.SELECTED);
      redrawButton (wdw, butBox, ob);
      (* Selektierte Nachrichten z„hlen *)
      selectCount := countSelectedEntries(ptr);
      checkPopups(selectCount);
      MagicAES.ObjcOffset (butBox, ob, x, y);
      CASE ob OF
        MausTauschrsc.listsel : (* Selektieren *)
          (* Popup en- bzw. disablen *)
          (*
          mtUtils.SetState (selPop, MausTauschrsc.lseltree, MagicAES.DISABLED, selectCount = 0);
          *)
          select := mtPopups.TreePopup (selPop, x, y, 0);
          CASE select OF
            MausTauschrsc.lseltree : selectTree (ptr, TRUE);
          | MausTauschrsc.lselnew  : msgList.listSelectNew (ptr^.wdw);
          | MausTauschrsc.lselall  : msgList.listSelectAll (ptr^.wdw, TRUE);
          | MausTauschrsc.lseltop  : selectFromTop (ptr);
          | MausTauschrsc.lselfind : doMark (ptr, TRUE);
          | MausTauschrsc.lselinvt : invertSelection (ptr);
          | MausTauschrsc.lunselrd : deselectReadEntries (ptr);
          | MausTauschrsc.lseldsel : deselectEntries (ptr);

          ELSE
          END;
      | MausTauschrsc.listshrink: (* Liste verkleinern *)
          (*
          mtUtils.SetState (removePop, MausTauschrsc.lremsel, MagicAES.DISABLED, selectCount = 0);
          mtUtils.SetState (removePop, MausTauschrsc.lremnsel, MagicAES.DISABLED, selectCount = 0);
          mtUtils.SetState (removePop, MausTauschrsc.lrembaum, MagicAES.DISABLED, selectCount = 0);
          *)
          select := mtPopups.TreePopup (removePop, x, y, 0);
          CASE select OF
            MausTauschrsc.lremsel  : IF ~shrinkList (ptr, TRUE, TRUE) THEN WdwManager.FullRedrawWdw (wdw); END;
          | MausTauschrsc.lremnsel : IF ~shrinkList (ptr, FALSE, TRUE) THEN WdwManager.FullRedrawWdw (wdw); END;
          | MausTauschrsc.lrembaum : removeTree (ptr);
          | MausTauschrsc.lremtop  : shrinkToEnd (ptr, TRUE);
          | MausTauschrsc.lremshow : showAll (ptr);
          ELSE
          END;
      | MausTauschrsc.listsort: (* Sortieren *)
          select := mtPopups.TreePopup (sortPop, x, y, 0);
          IF (select >= MausTauschrsc.lsortvon)
           & (select <= MausTauschrsc.lsortdat)
          THEN
            doSort (ptr, sortType (select-1), TRUE);
          END;
      | MausTauschrsc.listread: (* selektierte lesen *)
          mtUtils.Bounce();
          IF selectCount = 0
          THEN
            v.int := mtAlerts.Alert (1, MTE.noneSelAlt);
            IF v.int = 1
            THEN
              msgList.listSelectAll (ptr^.wdw, FALSE);
              (* Jetzt noch schnell die gefilterten entfernen *)
              listSelectFiltered (ptr^.wdw, FALSE, TRUE);
              (* Und jetzt die noch selektierten lesen *)
              openSelected (ptr, FALSE, MagicAES.KCTRL IN kstate);
            END;
          ELSE
            openSelected (ptr, FALSE, MagicAES.KCTRL IN kstate);
          END;
      ELSE
      END;
      (* Button deselektieren *)
      mtUtils.ExclState (butBox, ob, MagicAES.SELECTED);
      redrawButton (ptr^.wdw, butBox, ob);
      careForSelected (ptr, TRUE);
      RETURN TRUE
    END;
    RETURN FALSE;
  END;
END handleButtons;

PROCEDURE listMoveElems (ptr: listWdwPtr; x, y : INTEGER; buts, kstate: BITSET);
  TYPE oneEntry = RECORD line: ARRAY [0..4] OF GrafBase.Point; END;

  VAR pointArray: POINTER TO ARRAY [0..$FFFF] OF oneEntry;
      i         : CARDINAL;
      visible   : CARDINAL;
      j         : INTEGER;
      deltaX,
      deltaY,
      oldX,
      oldY : INTEGER;
      style: CARDINAL;
      xOutput, yOutput : INTEGER;
      hdl   : INTEGER;
      size  : LONGCARD;
      siz   : CARDINAL;
      data  : ADDRESS;
      apId  : INTEGER;

  PROCEDURE drawLines();
    VAR i : CARDINAL;
  BEGIN
    mtAppl.MouseOff();
    FOR i := 0 TO visible - 1 DO
      MagicVDI.Polyline (ptr^.vdi, 5, pointArray^[i].line);
    END;
    mtAppl.MouseOn();
  END drawLines;

BEGIN
  WITH ptr^ DO
    (* Erstmal sichtbare selektierte herausfinden *)
    visible := 0;
    FOR i := startPos TO maxPos DO
      IF Selected IN list^[i].flags THEN INC (visible) END;
    END;
    (* Jetzt Speicher fr Linien allozieren *)
    IF visible = 0 THEN RETURN END;
    ALLOCATE (pointArray, visible * 5 * TSIZE (GrafBase.Point));
    IF pointArray = NIL THEN RETURN END;
    (* Jetzt die Koordinaten fr die selektierten in das Pointarray eintragen *)
    visible := 0;
    FOR i := startPos TO maxPos DO
      IF Selected IN list^[i].flags THEN
        xOutput := listWork.x + pixOffset - leftOffset;
        yOutput := listWork.y + INTEGER(i - startPos) * (charHeight + lineDist) + (lineDist DIV 2);
        WITH pointArray^[visible] DO
          line[0].x := xOutput;
          line[0].y := yOutput;
          line[1].x := xOutput+entryWidth-1;
          line[1].y := yOutput;
          line[2].x := xOutput+entryWidth-1;
          line[2].y := yOutput+charHeight-1;
          line[3].x := xOutput;
          line[3].y := yOutput+charHeight-1;
          line[4].x := xOutput;
          line[4].y := yOutput;
        END;
        INC (visible);
      END;
    END;
    (* Alte Koordinaten merken *)
    oldX := x;
    oldY := y;
    (* Clipping auf Screen setzen *)
    MagicAES.WindUpdate (MagicAES.BEGMCTRL);
    WdwManager.SetClip (vdi, WdwManager.deskSize, TRUE);
    (* Schreibmodus setzen *)
    v.int := MagicVDI.SetWritemode (vdi, MagicVDI.XOR);
    (* Linientyp setzen *)
    v.int := MagicVDI.SetLinetype (vdi, MagicVDI.User);
    IF ODD (leftOffset)
    THEN
      style := $AAAA;
    ELSE
      style := $5555;
    END;
    MagicVDI.SetUserlinestyle (vdi, style);
    v.int := MagicVDI.SetLinewidth (vdi, 1);
    v.int := MagicVDI.SetLinecolor (vdi, 1);
    (* Jetzt die Linie zeichnen *)
    mtAppl.MouseHand();
    drawLines();
    REPEAT
      MagicAES.GrafMkstate (x, y, buts, kstate);
      IF (x # oldX) OR (y # oldY)
      THEN
        (* Linie wieder wegzeichnen an alten Koordinaten *)
        drawLines();
        (* Koordinaten anpassen *)
        deltaX := x - oldX;
        deltaY := y - oldY;
        FOR i := 0 TO visible - 1 DO
          WITH pointArray^[i] DO
            FOR j := 0 TO 4 DO
              INC (line[j].x, deltaX);
              INC (line[j].y, deltaY);
            END;
          END;
        END;
        (* Neue Outline zeichnen *)
        drawLines();
        oldX := x;
        oldY := y;
      END;
    UNTIL ~(0 IN buts);
    (* Outline wieder wegzeichnen *)
    drawLines();
    (* Writemode zurcksetzen *)
    v.int := MagicVDI.SetWritemode (vdi, MagicVDI.REPLACE);
    (* Clipping auf Workbereich setzen *)
    WdwManager.SetClip (vdi, listWork, TRUE);
    MagicAES.WindUpdate (MagicAES.ENDMCTRL);
    (* Drag und Drop ausfhren *)
    hdl := MagicAES.WindFind (x, y);
    IF hdl # wdw
    THEN
      MagicAES.WindUpdate (MagicAES.ENDUPDATE);
      IF ~WdwManager.WdwDDServe (wdw, x, y, kstate)
      THEN
        (* Das ganze per Message verschicken *)
        IF WdwManager.GetApId (hdl, apId)
        THEN
          currentExt := 0;
          listGetSelectedSize (ptr, size);
          listGetSelectedData (ptr, data);
          siz := SHORT (size);
          v.bool := Protokoll.Send2Filter (apId, siz, data)
        END;
      END;
      MagicAES.WindUpdate (MagicAES.BEGUPDATE);
    END;
    (* Mauszeiger zurcksetzen *)
    mtAppl.MouseArrow();
    (* Speicher freigeben *)
    DEALLOCATE (pointArray, 0);
  END;
END listMoveElems;

PROCEDURE clickInListWindow(win, vdiH : INTEGER; special : ADDRESS; x,y : INTEGER; kstate : BITSET; buts: BITSET; clicks : INTEGER): BOOLEAN;
  VAR transY : INTEGER;
      ptr    : listWdwPtr;
      entrySelected : BOOLEAN;
      line   : INTEGER;
      but    : BITSET;
      isOpen : BOOLEAN;
      ob     : INTEGER;
      clip   : GrafBase.Rectangle;
      kshift : BITSET;
      isSel  : BOOLEAN;


    PROCEDURE selectArea;
      VAR firstLine,
          lastLine : CARDINAL;
          i        : CARDINAL;
          r        : GrafBase.Rectangle;
          rect     : GrafBase.Rectangle;
          first    : BOOLEAN;
    BEGIN
      WITH ptr^ DO
        rect := GrafBase.Rectangle{x, y, 0, 0};
        mtAppl.MouseFinger ();
        MagicAES.GrafRubberbox (x, y, -32767, -32767, rect.w, rect.h);
        mtAppl.MouseArrow();

        WITH rect DO
          IF w < 0
          THEN
            INC(x, w);
            w := -w
          END;
          IF h < 0
          THEN
            INC (y, h);
            h := -h
          END;
        END;

        (* clippen *)
        rect := RectFuncs.ClipRect (rect, listWork);
        rect.h := BinOps.LowerInt (rect.h, listWork.y + listWork.h - 1 - rect.y);

        (* Jetzt testen, ob selektierbarer Bereich geschnitten wurde *)
        IF (((rect.x - listWork.x) < pixOffset) & ((rect.x + rect.w - listWork.x) < pixOffset)) OR
           (((rect.x - listWork.x) > maxWidth) & ((rect.x + rect.w - listWork.x) > maxWidth))
        THEN
          RETURN
        END;

        firstLine := (rect.y - listWork.y) DIV (charHeight + lineDist);
        lastLine  := (rect.y + rect.h - listWork.y) DIV (charHeight + lineDist);
        IF (rect.x - listWork.x > pixOffset) OR (rect.x + rect.w - listWork.x > pixOffset)
        THEN
          r := listWork;
          INC (r.x, pixOffset);
          r.h := charHeight + lineDist;
          first := TRUE;
          FOR i := startPos+firstLine TO startPos+lastLine DO
            IF (i >= 0) & (i <= maxPos)
            THEN
              toggleBit (list^[i].flags, Selected);
              IF (i >= startPos) & (i <= startPos + CARDINAL(windLines))
              THEN
                (* redraw *)
                IF first THEN
                  r.y := listWork.y + INTEGER(i - startPos) * (charHeight+lineDist);
                  first := FALSE
                ELSE
                  r.h := listWork.y + INTEGER(i - startPos + 1) * (charHeight+lineDist) - r.y;
                END;
              END;
            END;
          END;
          IF ~first THEN WdwManager.RedrawWdw (wdw, r) END;;
        END;
      END;
    END selectArea;

BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    (* Hier noch Baumposition anpassen *)
    WdwManager.GetWdwWork (wdw, clip);
    AdjustTreePos (clip, butWork);
    IF RectFuncs.IsInRect (x, y, butWork)
    THEN
      ob := MagicAES.ObjcFind (butBox,  0, 8, x, y);
      IF (ob >= MausTauschrsc.listsel) & (ob <= MausTauschrsc.listread)
      THEN
        RETURN handleButtons (ptr, ob, kstate);
      END;
    ELSIF RectFuncs.IsInRect (x, y, listWork)
    THEN
      ShowCursor (ptr); (* Cursor ausschalten *)
      cursPos := -1;
      (* Zeile herausfinden *)
      line := (y - listWork.y) DIV (charHeight + lineDist);
      transY := (y - listWork.y - (lineDist DIV 2));
      entrySelected := (transY >= line*(charHeight + lineDist)) &
                       (transY < ((line+1) * charHeight + line*lineDist)) &
                       ((x - listWork.x) >= pixOffset) &
                       ((x - listWork.x) <= maxWidth) &
                       (CARDINAL(line)+startPos <= maxPos);
      MagicAES.GrafMkstate (x, y, but, kshift);
      isSel := entrySelected & (Selected IN list^[CARDINAL(line)+startPos].flags);
      IF ~(isSel & (0 IN but)) & ~CatGlobal.WithShift (kstate)
      THEN
        deselectEntries (ptr);
      END;
      IF entrySelected
      THEN
        IF ~(isSel & (0 IN but))
        THEN
          toggleEntry (ptr, CARDINAL(line)+startPos);
        END;
        IF (clicks > 1) OR (~(0 IN buts) & (1 IN buts))
        THEN
          openSelected (ptr, ~(0 IN buts) & (1 IN buts), MagicAES.KCTRL IN kstate);
        ELSE
          IF (0 IN but)
          THEN
            (* Drag & Drop! *)
            listMoveElems (ptr, x, y, buts, kstate);
          END;
        END;
        (* Warten auf loslassen *)
        REPEAT
          MagicAES.GrafMkstate (x, y, but, kstate);
        UNTIL but = {};
      ELSE
        MagicAES.GrafMkstate (x, y, but, kstate);
        IF 0 IN but
        THEN
          (* Graf-Rubberbox aufrufen *)
          selectArea();
        END;
      END;
      careForSelected (ptr, TRUE);
      RETURN TRUE;
    END;
  END;
  RETURN FALSE;
END clickInListWindow;

PROCEDURE handleListTimer (wdw, vdiH : INTEGER; special : ADDRESS): BOOLEAN;
  VAR ptr   : listWdwPtr;
      i     : CARDINAL;
      max   : CARDINAL;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    IF startPos < MAX(CARDINAL) - CARDINAL (windLines)
    THEN
      max := BinOps.LowerCard (startPos+CARDINAL(windLines), maxPos);
    ELSE
      max := maxPos;
    END;
    max := BinOps.LowerCard (max, maxPos);
    FOR i := startPos TO max DO
      IF doRedraw IN list^[i].flags
      THEN
        redrawEntry (ptr, i);
      END;
    END;
    RETURN TRUE;
  END;
END handleListTimer;

PROCEDURE handleListKey (wdw, vdiH : INTEGER; special : ADDRESS; taste: INTEGER; char, scan : CHAR; kstate : BITSET) : BOOLEAN;
  VAR ptr   : listWdwPtr;
      gemCh : CARDINAL;
      key   : MOSGlobals.Key;
      ctrl  : BOOLEAN;
      shift : BOOLEAN;
      done  : BOOLEAN;
      doc   : GrafBase.LongRect;
      firstSel  : CARDINAL;
      selChanged: BOOLEAN;
      again : BOOLEAN;
      specCode: Keyboard.SpecialCode;
      handle : BOOLEAN;
      mode   : grinTools.ActionType;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    selChanged := FALSE;
    gemCh := ORD(scan) * 256 + ORD(char);
    Keyboard.GemCharToKey (gemCh,  SHORT (INTEGER(kstate)), key);
    ctrl := MagicAES.KCTRL IN kstate;
    shift := CatGlobal.WithShift (kstate);
    done := TRUE;
    IF (cursPos < LONGINT(LONG(startPos))) OR (cursPos > LONGINT(LONG(startPos + CARDINAL(windLines))) - 1)
    THEN
      cursPos := -1
    END;
    IF Keyboard.IsSpecial (key)
    THEN
      specCode := Keyboard.SpecialKey (key);
      REPEAT
        again := FALSE;
        CASE specCode OF
          left          : WdwManager.ScrollLeft (wdw, 1);  |
          soln          : WdwManager.PageLeft (wdw);    |
          right         : WdwManager.ScrollRight (wdw, 1); |
          eoln          : WdwManager.PageRight (wdw);   |
          pgUp          : WdwManager.PageUp (wdw); |
          pgDown        : WdwManager.PageDown (wdw); |
          up            : IF cursPos = -1
                          THEN
                            cursPos := LONGINT (LONG(startPos+CARDINAL(windLines)-1));
                          ELSE
                            ShowCursor (ptr); (* alten wegmachen *)
                            IF shift THEN
                              DEC (cursPos, windLines - 1);
                            ELSE
                              DEC (cursPos);
                            END;
                          END;
                          cursPos := BinOps.LowerLInt (maxPos, cursPos);
                          cursPos := BinOps.HigherLInt (0, cursPos);
                          IF cursPos >= LONGINT (LONG(startPos))
                          THEN
                            ShowCursor (ptr);
                          ELSE
                            IF shift
                            THEN
                              WdwManager.PageUp (wdw);
                            ELSE
                              WdwManager.ScrollUp (wdw, 1);
                            END;
                          END;
                          (*
                          WdwManager.ScrollUp (wdw, 1); *)   |
          down          :
                          IF cursPos = -1
                          THEN
                            cursPos := LONGINT (LONG(startPos));
                          ELSE
                            ShowCursor (ptr); (* alten wegmachen *)
                            IF shift THEN
                              INC (cursPos, windLines - 1);
                            ELSE
                              INC (cursPos);
                            END;
                          END;
                          cursPos := BinOps.LowerLInt (cursPos, maxPos);
                          cursPos := BinOps.HigherLInt (0, cursPos);
                          IF cursPos <= LONGINT (LONG(startPos + CARDINAL(windLines) - 1))
                          THEN
                            ShowCursor (ptr);
                          ELSE
                            IF shift THEN
                              WdwManager.PageDown (wdw);
                            ELSE
                              WdwManager.ScrollDown (wdw, 1);
                            END;
                          END;
                          (*
                          WdwManager.ScrollDown (wdw, 1); *) |
          altL,
          return,
          enter         : v.bool := handleButtons (ptr, MausTauschrsc.listread, kstate); |
          (* Buttons in Topleiste *)
          alt1          : v.bool := handleButtons (ptr, MausTauschrsc.listsel, kstate); |
          alt2          : v.bool := handleButtons (ptr, MausTauschrsc.listshrink, kstate); |
          alt3          : v.bool := handleButtons (ptr, MausTauschrsc.listsort, kstate); |
          (*
          return,
          enter         : openSelected (ptr, FALSE, ctrl) ; |
          *)
          insert        : IF cursPos >= 0 THEN
                            selChanged := TRUE;
                            toggleEntry (ptr, SHORT(LONGCARD(cursPos)));
                            (* Jetzt um einen nach unten bewegen *)
                            again := TRUE;
                            specCode := Keyboard.down;
                          END; |

          home,
          clr           : IF Keyboard.SpecialKey (key) = home
                          THEN
                            startPos := 0;
                          ELSE
                            IF CARDINAL(windLines) > maxPos THEN startPos := 0
                            ELSE startPos := maxPos - CARDINAL(windLines) + 1; END;
                          END;
                          WdwManager.SetWdwDocument (wdw, GrafBase.LongRect{LONG(leftOffset), startPos, LONG(maxWidth), maxPos});
                          |
        ELSE
          done := FALSE
        END;
      UNTIL ~again;
    ELSE
      IF char = ' '
      THEN
        WdwManager.GetWdwDocument (wdw, doc);
        IF doc.y > doc.h - LONG(windLines)
        THEN
          (* n„chste Seite nicht m”glich *)
          openSelected (ptr, FALSE, MagicAES.KCTRL IN kstate);
        ELSE
          WdwManager.PageDown (wdw);
        END;
      ELSE
        IF extendedCommentMode
        THEN
          handle := TRUE;
          CASE CAP(char) OF
            'B' : mode := grinTools.answer; |
            'G' : mode := grinTools.otherGroup; |
            'K' : mode := grinTools.comment; |
          ELSE
            handle := FALSE;
          END;
          IF handle & (countSelectedEntries (ptr) = 1)
          THEN
            (* Nachricht anzeigen und dann grintools mit Action aufrufen *)
            openSelected (ptr, FALSE, FALSE);
            grinTools.Handle (grinWindow, mode);
          ELSE
            done := FALSE;
          END;
        ELSE
          done := FALSE;
        END;
      END;
    END;
    IF selChanged THEN careForSelected(ptr, TRUE); END;
    RETURN done;
  END;
END handleListKey;

PROCEDURE getListScroll (wdw, vdiH : INTEGER; special : ADDRESS; VAR work : GrafBase.Rectangle);
  VAR ptr       : listWdwPtr;
      varName   : ARRAY [0..255] OF CHAR;
      full      : GrafBase.Rectangle;
BEGIN
  ptr := listWdwPtr (special);
  AdjustTreePos (work, ptr^.butWork);
  DEC (work.h, butBox^[0].obHeight+1);
  INC (work.y, butBox^[0].obHeight+1);
  WITH work DO
    ptr^.windLines := BinOps.HigherInt (0, (BinOps.LowerInt(y+h-1, INTEGER(mtAppl.MaxHeight-1)) - y+1) DIV (ptr^.charHeight+lineDist));
    WdwManager.SetScrollParms (wdw, w-ptr^.charWidth, ptr^.windLines-1, ptr^.charWidth, 1);
    ptr^.listWork := work;
  END;
  WITH ptr^ DO
    IF wdw >= 0
    THEN
      Strings.Concat (cListWdw, StrConv.IntToStr (number, 0), varName, v.bool);
      WdwManager.GetWdwSize (wdw, full);                (* Gr”že des Fensters abfragen *)
      v.bool := ConfVars.SetConfigRect (varName, full);
    END;
  END;
END getListScroll;

PROCEDURE closeListWindow (wdw, vdiH : INTEGER; special : ADDRESS; force : BOOLEAN) : BOOLEAN;
  VAR ptr : listWdwPtr;
      varName : CatTypes.String255;
      full    : GrafBase.Rectangle;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    Strings.Concat (cListWdw, StrConv.IntToStr (number, 0), varName, v.bool);
    WdwManager.GetWdwSize  (wdw, full); (* Gr”že des Fensters abfragen *)
    v.bool := ConfVars.SetConfigRect (varName, full);
    Strings.Concat (cListFont, StrConv.IntToStr (number, 0), varName, v.bool);
    v.bool := ConfVars.SetConfigInt (varName, font);
    Strings.Concat (cListSize, StrConv.IntToStr (number, 0), varName, v.bool);
    v.bool := ConfVars.SetConfigInt (varName, fontSize);
    v.bool := ConfVars.SetConfigInt (cListLeftOffset, pixOffset);
    v.bool := ConfVars.SetConfigInt (cListLineDist, lineDist);
    ClearNum (number);
    FontSelect.UnloadFonts (vdi);
  END;
  IF (ptr^.usedByGrin = 0) OR force
  THEN
    freeList (ptr);
    handlePool.FreeOneDataHandle(ptr^.grHandle);
    handlePool.FreeOnePtr(ptr, windows);
  ELSE
    ptr^.wdw := -1;
    ptr^.vdi := -1;
  END;
  RETURN TRUE
END closeListWindow;

PROCEDURE topListWdw (wdw, vdiH : INTEGER; special : ADDRESS) : BOOLEAN;
BEGIN
  RETURN TRUE;
END topListWdw;

PROCEDURE untopListWdw (wdw, vdiH : INTEGER; special : ADDRESS);
END untopListWdw;

PROCEDURE updateListWdw (wdw, vdiH : INTEGER; special : ADDRESS; update : BOOLEAN);
BEGIN
  IF update
  THEN
    MagicAES.WindUpdate (MagicAES.BEGUPDATE);
    mtAppl.MouseOff();
  ELSE
    mtAppl.MouseOn();
    MagicAES.WindUpdate (MagicAES.ENDUPDATE);
  END;
END updateListWdw;

PROCEDURE hideListWdw (wdw, vdiH : INTEGER; special : ADDRESS; hide : BOOLEAN);
  VAR ptr : listWdwPtr;
BEGIN
  ptr := listWdwPtr (special);
  ptr^.isHidden := hide;
END hideListWdw;

PROCEDURE setListWork (wdw, vdiH : INTEGER; special : ADDRESS; doc : GrafBase.LongRect; slided : BOOLEAN);
  VAR ptr : listWdwPtr;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    leftOffset := SHORT(doc.x);
    startPos   := VAL (CARDINAL, doc.y);
    IF (cursPos < doc.y) OR (cursPos > doc.y + LONGINT (LONG(windLines)) - 1)
    THEN
      cursPos := -1
    END;
  END;
END setListWork;

PROCEDURE snapListWdw (wdw, vdiH : INTEGER; special : ADDRESS; VAR work : GrafBase.Rectangle);
  CONST minWindWidth = 80;
        minWindHeight = 80;
  VAR ptr       : listWdwPtr;
      minWdwH   : INTEGER;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    IF font >= 0
    THEN
      AdjustTreePos (work, butWork);
      WITH work DO
        DEC (h, butWork.h);
        minWdwH := minWindHeight - butWork.h;
        INC(h);         (* Um Rundungsfehler zu vermeiden *)
        h := (h DIV (charHeight+lineDist)) * (charHeight+lineDist);
        WHILE w < minWindWidth DO INC(w, charWidth) END;
        WHILE h < minWdwH DO INC(h, charHeight+lineDist) END;
        windLines := BinOps.HigherInt (0, (BinOps.LowerInt(y+h-1, INTEGER(mtAppl.MaxHeight-1)) - y+1) DIV (charHeight+lineDist));
        listWork := work;
        INC (work.h, butWork.h);
        WdwManager.SetScrollParms (wdw, w-charWidth, windLines-1, charWidth, 1);
      END;
    END;
  END;
END snapListWdw;

CONST   cFrom = 'From: ';
        cTopic = 'Subject: ';
        cGroup = 'Group: ';
        cTAB  = 011C;

PROCEDURE listGetSelectedSize (ptr: listWdwPtr; VAR size: LONGCARD);
VAR   i   : CARDINAL;
      j   : INTEGER;
      sels: CARDINAL;
BEGIN
  WITH ptr^ DO
    (* Eine einfache Schleife reicht, in der ich in jeder Zeile die Bytes z„hle *)
    size := 0;
    sels := countSelectedEntries (ptr);
    IF sels > 0
    THEN
      IF currentExt = 0 (* Filter-Daten *)
      THEN
        (* Wir bergeben folgendes:
         * From: Absender, 256 Zeichen
         * TAB
         * Topic: Betreff, 256 Zeichen
         * TAB
         *)
        size := LENGTH (cFrom) + LENGTH (cTopic) + LENGTH (cGroup) + 771 (* 256*3 + 3 *);
        size := size * LONG(sels);
      ELSE
        (* Platzbedarf einer Zeile ermitteln *)
        FOR j := 0 TO partArray.lines-1 DO
          INC (size, partArray.parts[j].w+1);
          IF currentExt = 2 (* CSV *)
          THEN INC (size, 2) (* Fr Anfhrungszeichen *)
          END;
        END;
        INC (size);    (* Fr CR/LF *)
        (* Jetzt multiplizieren wir das nur noch mit der Anzahl der Zeilen,
         * und schon haben wir den ben”tigten Platz
         *)
        size := size * LONG(sels);
      END;
    END;
  END;
END listGetSelectedSize;

PROCEDURE listGetSelectedData (ptr: listWdwPtr; VAR adr: ADDRESS);
CONST
        LF =            12C;
        CR =            15C;

  VAR text: CatTypes.LargeTextPtr;
      idx : LONGCARD;
      i   : CARDINAL;
      k   : LONGCARD;
      j   : INTEGER;
      mess: data.MessageType;
      line: ARRAY [0..1023] OF CHAR;
      gName: CatTypes.String255;
BEGIN
  WITH ptr^ DO
    IF dataSize > 0 THEN INC (dataSize) END;
    ALLOCATE (adr, dataSize);
    IF adr = NIL THEN RETURN END;
    text := adr;
    idx := 0;
    (* Eine einfache Schleife reicht, in der ich in jeder Zeile die Bytes z„hle *)
    FOR i := 0 TO maxPos DO
      IF Selected IN list^[i].flags THEN
        (* Header der Message lesen *)
        data.ReadHeader (grHandle^.Zugriff, list^[i].msgNum, mess);
        IF data.error # data.noError
        THEN
          WITH mess DO
            MailID := NIL;
            Betreff := NIL;
            Absender := NIL;
            Empfaenger := NIL;
            mid := NIL;
            rid := NIL;
            box := NIL;
            name := NIL;
            InfoStrings := NIL;
          END;
        END;
        IF currentExt = 0 (* Filterdaten *)
        THEN
          Block.Copy (CADR(cFrom), LENGTH (cFrom), ADR(text^[idx]));
          INC (idx, LENGTH (cFrom));
          (* Feld kopieren *)
          FOR k := 0 TO 255 DO
            text^[idx+k] := ' ';
          END;
          IF mess.Absender # NIL
          THEN
            Block.Copy (mess.Absender, LENGTH (mess.Absender^), ADR(text^[idx]));
          END;
          INC (idx, 256);
          Block.Copy (CADR(cTAB), 1, ADR(text^[idx]));
          INC (idx);
          Block.Copy (CADR(cTopic), LENGTH (cTopic), ADR(text^[idx]));
          INC (idx, LENGTH (cTopic));
          (* zweites Feld kopieren *)
          FOR k := 0 TO 255 DO
            text^[idx+k] := ' ';
          END;
          IF mess.Betreff # NIL
          THEN
            Block.Copy (mess.Betreff, LENGTH (mess.Betreff^), ADR(text^[idx]));
          END;
          INC (idx, 256);
          Block.Copy (CADR(cTAB), 1, ADR(text^[idx]));
          INC (idx);
          (* Gruppe anh„ngen *)
          Block.Copy (CADR(cGroup), LENGTH (cGroup), ADR(text^[idx]));
          INC (idx, LENGTH (cGroup));
          (* zweites Feld kopieren *)
          FOR k := 0 TO 255 DO
            text^[idx+k] := ' ';
          END;
          GroupSelect.GroupName (mess.Gruppe, gName);
          Block.Copy (ADR(gName), LENGTH (gName), ADR(text^[idx]));
          INC (idx, 256);
          Block.Copy (CADR(cTAB), 1, ADR(text^[idx]));
          INC (idx);
        ELSE
          (* Zeile aufbauen und Bytes z„hlen *)
          FOR j := 0 TO partArray.lines-1 DO
            IF currentExt = 2 (* CSV *)
            THEN
              (* Ein Anfhrungszeichen schreiben *)
              text^[idx] := '"';
              INC (idx);
            END;
            GetLinePart (ptr, list^[i].msgNum, mess, line, partArray.parts[j]);
            Strings.Append (Strings.Space (partArray.parts[j].w - INTEGER(LENGTH (line))), line, v.bool);
            Block.Copy (ADR(line), partArray.parts[j].w, ADR(text^[idx]));
            INC (idx, partArray.parts[j].w);
            IF currentExt = 2 (* CSV *)
            THEN
              (* Ein Anfhrungszeichen schreiben *)
              text^[idx] := '"';
              INC (idx);
            END;
            (* Eintr„ge mit Komma trennen *)
            IF j < partArray.lines-1 THEN
              IF currentExt = 2 THEN
                text^[idx] := ',';
              ELSE
                text^[idx] := ' ';
              END;
              INC (idx);
            END;
          END; (* FOR j *)
          text^[idx] := CR;
          text^[idx+1] := LF;
          INC (idx, 2);
        END;
        (* Speicher freigeben *)
        IF mess.InfoStrings # NIL THEN
          DEALLOCATE (mess.InfoStrings, 0);
        END;
      END;
    END;
    IF (idx >= dataSize) THEN
      HALT
    ELSE
      text^[idx] := 0C;
    END;
  END;
END listGetSelectedData;

TYPE listExtsType   = ARRAY [0..7] OF ARRAY [0..3] OF CHAR;

CONST listExts = listExtsType{'.FLT','.TXT','.CSV',0C+0C+0C+0C BY 5};
      maxSendExts   = 3;

PROCEDURE listGetHeader (wdw: INTEGER; special: ADDRESS; mode: INTEGER;
                         VAR ext, name : ARRAY OF CHAR; VAR size: LONGCARD): BOOLEAN;

CONST   cListName  = 'CAT Messageliste'+0C;
        cFiltName  = 'CAT Filterinformation'+0C;

  VAR ptr   : listWdwPtr;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    IF mode = WdwManager.HDRFIRST
    THEN
      currentExt := 0;
    ELSE
      INC (currentExt);
    END;
    IF currentExt >= maxSendExts THEN RETURN FALSE END;
    Strings.Assign (listExts[currentExt], ext, v.bool);
    IF currentExt = 0
    THEN
      Strings.Assign (cFiltName, name, v.bool);
    ELSE
      Strings.Assign (cListName, name, v.bool);
    END;
    listGetSelectedSize (ptr, size);
    dataSize := size;
    RETURN size > 0;
  END;
END listGetHeader;

PROCEDURE listReadData (wdw: INTEGER; special: ADDRESS; VAR data: ADDRESS);
  VAR ptr   : listWdwPtr;
BEGIN
  ptr := listWdwPtr (special);
  WITH ptr^ DO
    listGetSelectedData (ptr, data);
  END;
END listReadData;

PROCEDURE MakeTitle (gruppe: CARDINAL; VAR title: ARRAY OF CHAR);
BEGIN
  GroupSelect.GroupName (gruppe, title);
  ConfVars.GetConfDefBool (cSetAppName, v.bool, TRUE);
  IF CatGlobal.multiTask & v.bool
  THEN
    MagicStrings.Insert ('[CAT] ', title, 0);
  END;
  MagicStrings.Insert (' ', title, 0);
  MagicStrings.Append (' ', title);
END MakeTitle;

END MsgListBase.